/**
 * 💬 消息本地存储工具类
 * 
 * 功能：
 * - 存储和读取聊天消息（按好友ID分类）
 * - 存储好友申请消息
 * - 存储活动申请消息
 * - 消息去重
 * - 消息排序
 */

const storage = require('./storage.js');
const lastContact = require('./lastContact.js'); // 🔥 引入最后联系时间工具类

// 存储键名前缀
const STORAGE_PREFIX = {
  CHAT_MESSAGE: 'chat_msg_',           // 聊天消息：chat_msg_{friendId}
  FRIEND_REQUEST: 'friend_request_',   // 好友申请：friend_request_{userId}
  ACTIVITY_REQUEST: 'activity_request_', // 活动申请：activity_request_{activityId}
  MESSAGE_INDEX: 'message_index'       // 消息索引（所有会话列表）
};

// 消息类型
const MESSAGE_TYPE = {
  TEXT: 'text',                        // 文本消息
  FRIEND_REQUEST: 'friend_request',    // 好友申请
  ACTIVITY_REQUEST: 'activity_request' // 活动申请
};

/**
 * 🔥 保存聊天消息（单条）
 * @param {string} friendId - 好友ID
 * @param {Object} message - 消息对象
 * @param {string} message.id - 消息ID
 * @param {string} message.content - 消息内容
 * @param {boolean} message.isSelf - 是否是自己发送的
 * @param {number} message.sentTime - 发送时间戳
 * @param {string} message.messageType - 消息类型
 */
function saveChatMessage(friendId, message) {
  try {
    console.log('💾 保存聊天消息:', friendId, message);
    
    const key = STORAGE_PREFIX.CHAT_MESSAGE + friendId;
    let messages = getChatMessages(friendId);
    
    // 检查是否已存在（去重）
    const existsById = messages.some(msg => msg.id === message.id);
    const existsByContent = messages.some(msg => 
      msg.content === message.content && 
      Math.abs(msg.sentTime - message.sentTime) < 1000
    );
    
    if (existsById || existsByContent) {
      console.log('⚠️ 消息已存在，跳过保存');
      console.log('   📝 消息ID:', message.id);
      console.log('   📝 消息内容:', message.content);
      console.log('   📝 发送时间:', message.sentTime);
      console.log('   🔍 ID重复:', existsById);
      console.log('   🔍 内容+时间重复:', existsByContent);
      
      if (existsByContent) {
        // 找出重复的消息
        const duplicateMsg = messages.find(msg => 
          msg.content === message.content && 
          Math.abs(msg.sentTime - message.sentTime) < 1000
        );
        console.log('   🔍 重复消息详情:', duplicateMsg);
        console.log('   🔍 时间差:', Math.abs(duplicateMsg.sentTime - message.sentTime), 'ms');
      }
      
      return false;
    }
    
    // 添加时间戳
    message.savedAt = Date.now();
    
    // 添加到列表
    messages.push(message);
    
    // 按时间排序
    messages.sort((a, b) => a.sentTime - b.sentTime);
    
    // 限制最多保存1000条消息（避免存储过大）
    if (messages.length > 1000) {
      messages = messages.slice(-1000);
    }
    
    // 保存到本地
    storage.set(key, messages);
    
    // 更新消息索引
    updateMessageIndex(friendId, message);
    
    // 🔥 更新最后联系时间（使用消息的发送时间）
    lastContact.updateContactTime(String(friendId), message.sentTime);
    
    console.log('✅ 消息保存成功，当前总数:', messages.length);
    return true;
  } catch (error) {
    console.error('❌ 保存消息失败:', error);
    return false;
  }
}

/**
 * 🔥 批量保存聊天消息
 * @param {string} friendId - 好友ID
 * @param {Array} messageList - 消息列表
 */
function saveChatMessages(friendId, messageList) {
  try {
    console.log('💾 批量保存聊天消息:', friendId, messageList.length);
    
    const key = STORAGE_PREFIX.CHAT_MESSAGE + friendId;
    let existingMessages = getChatMessages(friendId);
    
    // 过滤重复消息
    const newMessages = messageList.filter(newMsg => {
      return !existingMessages.some(existMsg => 
        existMsg.id === newMsg.id || 
        (existMsg.content === newMsg.content && 
         Math.abs(existMsg.sentTime - newMsg.sentTime) < 1000)
      );
    });
    
    if (newMessages.length === 0) {
      console.log('⚠️ 没有新消息需要保存');
      return false;
    }
    
    // 添加时间戳
    newMessages.forEach(msg => {
      msg.savedAt = Date.now();
    });
    
    // 合并消息
    let allMessages = [...existingMessages, ...newMessages];
    
    // 按时间排序
    allMessages.sort((a, b) => a.sentTime - b.sentTime);
    
    // 限制最多保存1000条消息
    if (allMessages.length > 1000) {
      allMessages = allMessages.slice(-1000);
    }
    
    // 保存到本地
    storage.set(key, allMessages);
    
    // 更新消息索引（使用最新的一条消息）
    if (newMessages.length > 0) {
      const latestMessage = newMessages[newMessages.length - 1];
      updateMessageIndex(friendId, latestMessage);
      
      // 🔥 更新最后联系时间（使用最新消息的发送时间）
      lastContact.updateContactTime(String(friendId), latestMessage.sentTime);
    }
    
    console.log('✅ 批量保存成功，新增:', newMessages.length, '条，总数:', allMessages.length);
    return true;
  } catch (error) {
    console.error('❌ 批量保存消息失败:', error);
    return false;
  }
}

/**
 * 🔥 获取聊天消息列表
 * @param {string} friendId - 好友ID
 * @returns {Array} 消息列表
 */
function getChatMessages(friendId) {
  try {
    const key = STORAGE_PREFIX.CHAT_MESSAGE + friendId;
    const messages = storage.get(key);
    return Array.isArray(messages) ? messages : [];
  } catch (error) {
    console.error('❌ 获取消息失败:', error);
    return [];
  }
}

/**
 * 🔥 获取最后一条消息
 * @param {string} friendId - 好友ID
 * @returns {Object|null} 最后一条消息对象，如果没有消息返回null
 */
function getLastMessage(friendId) {
  try {
    const messages = getChatMessages(friendId);
    if (messages.length === 0) {
      return null;
    }
    
    // 返回最后一条消息
    return messages[messages.length - 1];
  } catch (error) {
    console.error('❌ 获取最后一条消息失败:', error);
    return null;
  }
}

/**
 * 🔥 清空聊天消息
 * @param {string} friendId - 好友ID
 */
function clearChatMessages(friendId) {
  try {
    const key = STORAGE_PREFIX.CHAT_MESSAGE + friendId;
    storage.remove(key);
    console.log('✅ 聊天消息已清空:', friendId);
    return true;
  } catch (error) {
    console.error('❌ 清空消息失败:', error);
    return false;
  }
}

/**
 * 🔥 更新消息索引（用于显示会话列表）
 * @param {string} friendId - 好友ID
 * @param {Object} latestMessage - 最新消息
 */
function updateMessageIndex(friendId, latestMessage) {
  try {
    const index = storage.get(STORAGE_PREFIX.MESSAGE_INDEX) || {};
    
    index[friendId] = {
      friendId: friendId,
      latestMessage: latestMessage.content,
      latestTime: latestMessage.sentTime,
      unreadCount: index[friendId] ? (index[friendId].unreadCount || 0) : 0,
      updatedAt: Date.now()
    };
    
    storage.set(STORAGE_PREFIX.MESSAGE_INDEX, index);
  } catch (error) {
    console.error('❌ 更新消息索引失败:', error);
  }
}

/**
 * 🔥 获取消息索引
 * @returns {Object} 消息索引对象
 */
function getMessageIndex() {
  try {
    return storage.get(STORAGE_PREFIX.MESSAGE_INDEX) || {};
  } catch (error) {
    console.error('❌ 获取消息索引失败:', error);
    return {};
  }
}

/**
 * 🔥 保存好友申请消息
 * @param {Object} request - 好友申请对象
 */
function saveFriendRequest(request) {
  try {
    const key = STORAGE_PREFIX.FRIEND_REQUEST + request.userId;
    storage.set(key, {
      ...request,
      type: MESSAGE_TYPE.FRIEND_REQUEST,
      savedAt: Date.now()
    });
    console.log('✅ 好友申请已保存:', request.userId);
    return true;
  } catch (error) {
    console.error('❌ 保存好友申请失败:', error);
    return false;
  }
}

/**
 * 🔥 获取所有好友申请
 * @returns {Array} 好友申请列表
 */
function getFriendRequests() {
  try {
    // TODO: 实现获取所有好友申请的逻辑
    // 需要遍历所有以 friend_request_ 开头的键
    return [];
  } catch (error) {
    console.error('❌ 获取好友申请失败:', error);
    return [];
  }
}

/**
 * 🔥 保存活动申请消息
 * @param {Object} request - 活动申请对象
 */
function saveActivityRequest(request) {
  try {
    const key = STORAGE_PREFIX.ACTIVITY_REQUEST + request.activityId;
    const requests = storage.get(key) || [];
    
    // 避免重复
    const exists = requests.some(r => r.userId === request.userId);
    if (!exists) {
      requests.push({
        ...request,
        type: MESSAGE_TYPE.ACTIVITY_REQUEST,
        savedAt: Date.now()
      });
      storage.set(key, requests);
    }
    
    console.log('✅ 活动申请已保存:', request.activityId);
    return true;
  } catch (error) {
    console.error('❌ 保存活动申请失败:', error);
    return false;
  }
}

/**
 * 🔥 获取活动申请列表
 * @param {string} activityId - 活动ID
 * @returns {Array} 活动申请列表
 */
function getActivityRequests(activityId) {
  try {
    const key = STORAGE_PREFIX.ACTIVITY_REQUEST + activityId;
    const requests = storage.get(key);
    return Array.isArray(requests) ? requests : [];
  } catch (error) {
    console.error('❌ 获取活动申请失败:', error);
    return [];
  }
}

/**
 * 🔥 处理并保存融云消息（统一入口）
 * @param {Object} rongCloudMessage - 融云原始消息对象
 * @returns {Object|null} 处理后的消息对象，如果处理失败返回null
 */
function processAndSaveRongCloudMessage(rongCloudMessage) {
  try {
    console.log('🔄 =============== 处理融云消息 ===============');
    console.log('📨 原始消息:', rongCloudMessage);
    
    // 只处理私聊文本消息
    if (rongCloudMessage.conversationType !== 1 || rongCloudMessage.messageType !== 'RC:TxtMsg') {
      console.log('⚠️ 非私聊文本消息，跳过处理');
      return null;
    }
    
    // 获取当前用户信息
    const userInfo = storage.getUserInfo();
    if (!userInfo) {
      console.warn('⚠️ 未找到用户信息，无法保存消息');
      return null;
    }
    
    const currentUserId = userInfo.userid;
    
    // 🔥 关键：将手机号（融云用户ID）转换为数据库ID
    const senderPhone = rongCloudMessage.senderUserId; // 发送者手机号
    
    // 从映射表获取数据库ID
    const phoneToIdMap = storage.get('phone_to_id_map') || {};
    let friendId = phoneToIdMap[senderPhone];
    
    if (!friendId) {
      console.warn('⚠️ 未找到手机号映射，使用手机号作为ID:', senderPhone);
      friendId = senderPhone; // 降级方案
    }
    
    console.log('📝 消息映射: 手机号', senderPhone, '→ 数据库ID', friendId);
    
    // 转换消息格式
    const processedMessage = {
      id: rongCloudMessage.messageId,
      content: rongCloudMessage.content.content || rongCloudMessage.content.text || '[无法显示的消息]',
      isSelf: false, // 收到的消息，不是自己发的
      time: formatMessageTime(rongCloudMessage.sentTime),
      sentTime: rongCloudMessage.sentTime,
      messageType: rongCloudMessage.messageType
    };
    
    // 🔥 使用数据库ID保存消息
    const saved = saveChatMessage(String(friendId), processedMessage);
    
    if (saved) {
      console.log('✅ 融云消息处理完成: 手机号', senderPhone, '→ 数据库ID', friendId);
      
      // 返回处理后的消息对象（包含friendId，供调用者使用）
      return {
        ...processedMessage,
        friendId: String(friendId),
        friendPhone: senderPhone
      };
    }
    
    return null;
  } catch (error) {
    console.error('❌ 处理融云消息失败:', error);
    return null;
  }
}

/**
 * 🔥 格式化消息时间
 * @param {number} timestamp - 时间戳
 * @returns {string} 格式化后的时间 HH:MM
 */
function formatMessageTime(timestamp) {
  const date = new Date(timestamp);
  const hours = date.getHours().toString().padStart(2, '0');
  const minutes = date.getMinutes().toString().padStart(2, '0');
  return `${hours}:${minutes}`;
}

/**
 * 🔥 清除所有消息（用于退出登录）
 */
function clearAllMessages() {
  try {
    console.log('🗑️ 清除所有消息...');
    
    // 清除消息索引
    storage.remove(STORAGE_PREFIX.MESSAGE_INDEX);
    
    // TODO: 清除所有聊天消息、好友申请、活动申请
    // 由于微信小程序没有直接遍历所有键的API，这里需要基于索引来清除
    
    console.log('✅ 所有消息已清除');
    return true;
  } catch (error) {
    console.error('❌ 清除消息失败:', error);
    return false;
  }
}

module.exports = {
  // 🔥 融云消息处理（统一入口）
  processAndSaveRongCloudMessage,
  
  // 聊天消息
  saveChatMessage,
  saveChatMessages,
  getChatMessages,
  getLastMessage,      // 🔥 新增：获取最后一条消息
  clearChatMessages,
  
  // 消息索引
  updateMessageIndex,
  getMessageIndex,
  
  // 好友申请
  saveFriendRequest,
  getFriendRequests,
  
  // 活动申请
  saveActivityRequest,
  getActivityRequests,
  
  // 清除
  clearAllMessages,
  
  // 常量
  MESSAGE_TYPE,
  STORAGE_PREFIX
};

